package sv1

import (
	"github.com/gin-gonic/gin"
	"github.com/spf13/cast"
	"go-vue/admin/adapt"
	"go-vue/admin/model"
	"go-vue/admin/utils"
	"strings"
)

type Roles struct {
}

// InitList 菜单列表（编辑列表）
func (role *Roles) InitList(ctx *gin.Context) {
	editList := new(model.SystemRoles).GetAllInitRoles()
	utils.OutSuccess(ctx, editList)
}

// EditList 菜单列表（编辑列表）
func (role *Roles) EditList(ctx *gin.Context) {
	//权限控制
	if adapt.ComparePermission(ctx, "role.list") {
		utils.Forbidden(ctx,"role.list")
		return
	}
	editList := new(model.SystemRoles).GetAllEditRoles()
	utils.OutSuccess(ctx, editList)
}

// EditSave 保存列表（编辑列表）
func (role *Roles) EditSave(ctx *gin.Context) {
	//权限控制
	if adapt.ComparePermission(ctx, "role.edit") {
		utils.Forbidden(ctx,"role.edit")
		return
	}
	input := &model.SystemRolesEditList{}
	err := ctx.BindJSON(input)
	if err != nil {
		utils.OutWrong(ctx, 400, "解析数据错误", nil)
		return
	}

	id, err := new(model.SystemRoles).SaveEditRole(input)
	if err != nil {
		utils.OutWrong(ctx, 500, "保存失败", err.Error())
		return
	}

	//回显
	roleInfo := &model.SystemRoles{RoleId: id}
	roleInfo.One()
	info := &model.SystemRolesEditList{
		Id:       id,
		ParentId: roleInfo.RolePid,
		Label:    roleInfo.RoleLabel,
		Sort:     roleInfo.RoleSort,
		Alias:    roleInfo.RoleAlias,
		State:    roleInfo.State,
		Children: nil,
	}
	utils.OutSuccess(ctx, info)
}

//EditDel 删除列表（编辑列表）
func (role *Roles) EditDel(ctx *gin.Context) {
	//权限控制
	if adapt.ComparePermission(ctx, "role.delete") {
		utils.Forbidden(ctx,"role.delete")
		return
	}
	input := &model.DeleteInputIds{}
	err := ctx.BindJSON(input)
	if err != nil {
		utils.OutWrong(ctx, 400, "解析数据错误", err)
		return
	}

	err = new(model.SystemRoles).DelEditRole(input)
	if err != nil {
		utils.OutWrong(ctx, 500, "保存失败", err.Error())
		return
	}

	utils.OutSuccess(ctx, nil)
}

// EditListPermission 菜单列表权限（编辑列表）
func (role *Roles) EditListPermission(ctx *gin.Context) {
	//权限控制
	if adapt.ComparePermission(ctx, "role.permission") {
		utils.Forbidden(ctx,"role.permission")
		return
	}

	roleId := ctx.Query("role_id")
	editList := new(model.SystemMenu).GetAllMenuPermission()

	//查询已经存在的权限
	var permission []string
	p := (&model.SystemPermission{
		Type:       model.PermissionRole,
		RelationId: cast.ToInt64(roleId),
	}).One()
	if p != nil {
		permission = strings.Split(p.Permissions, ",")
	}
	result := make(map[string]interface{})
	result["list"] = editList
	result["permission"] = permission

	utils.OutSuccess(ctx, result)
}

// EditSavePermission 菜单列表权限（编辑列表）
type savePermission struct {
	RoleId  int64    `json:"role_id"`
	Checked []string `json:"checked"`
}

func (role *Roles) EditSavePermission(ctx *gin.Context) {
	//权限控制
	if adapt.ComparePermission(ctx, "role.permission") {
		utils.Forbidden(ctx,"role.permission")
		return
	}
	input := &savePermission{}
	err := ctx.BindJSON(input)
	if err != nil {
		utils.OutWrong(ctx, 400, "解析数据错误", nil)
		return
	}

	//重新已经存在的权限
	err = (&model.SystemPermission{
		Type:        model.PermissionRole,
		RelationId:  input.RoleId,
		Permissions: strings.Join(input.Checked, ","),
	}).Save()
	if err != nil {
		utils.OutWrong(ctx, 500, "数据保存失败", err)
		return
	}
	utils.OutSuccess(ctx, nil)
}
